package cn.edu.sdju.fengguoyu.proto;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.52.1)",
    comments = "Source: AhoEdgeRegisterService.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class RegisterServiceGrpc {

  private RegisterServiceGrpc() {}

  public static final String SERVICE_NAME = "aho_edge.RegisterService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest,
      cn.edu.sdju.fengguoyu.proto.ServicesList> getQueryServicesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "queryServices",
      requestType = cn.edu.sdju.fengguoyu.proto.QueryRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.ServicesList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest,
      cn.edu.sdju.fengguoyu.proto.ServicesList> getQueryServicesMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest, cn.edu.sdju.fengguoyu.proto.ServicesList> getQueryServicesMethod;
    if ((getQueryServicesMethod = RegisterServiceGrpc.getQueryServicesMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getQueryServicesMethod = RegisterServiceGrpc.getQueryServicesMethod) == null) {
          RegisterServiceGrpc.getQueryServicesMethod = getQueryServicesMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.QueryRequest, cn.edu.sdju.fengguoyu.proto.ServicesList>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "queryServices"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.QueryRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServicesList.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("queryServices"))
              .build();
        }
      }
    }
    return getQueryServicesMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest,
      cn.edu.sdju.fengguoyu.proto.ServicesDetailList> getQueryServiceDetailMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "queryServiceDetail",
      requestType = cn.edu.sdju.fengguoyu.proto.QueryRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.ServicesDetailList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest,
      cn.edu.sdju.fengguoyu.proto.ServicesDetailList> getQueryServiceDetailMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest, cn.edu.sdju.fengguoyu.proto.ServicesDetailList> getQueryServiceDetailMethod;
    if ((getQueryServiceDetailMethod = RegisterServiceGrpc.getQueryServiceDetailMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getQueryServiceDetailMethod = RegisterServiceGrpc.getQueryServiceDetailMethod) == null) {
          RegisterServiceGrpc.getQueryServiceDetailMethod = getQueryServiceDetailMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.QueryRequest, cn.edu.sdju.fengguoyu.proto.ServicesDetailList>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "queryServiceDetail"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.QueryRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServicesDetailList.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("queryServiceDetail"))
              .build();
        }
      }
    }
    return getQueryServiceDetailMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest,
      cn.edu.sdju.fengguoyu.proto.ServiceResponse> getGetServiceMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "getService",
      requestType = cn.edu.sdju.fengguoyu.proto.QueryRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.ServiceResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest,
      cn.edu.sdju.fengguoyu.proto.ServiceResponse> getGetServiceMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.QueryRequest, cn.edu.sdju.fengguoyu.proto.ServiceResponse> getGetServiceMethod;
    if ((getGetServiceMethod = RegisterServiceGrpc.getGetServiceMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getGetServiceMethod = RegisterServiceGrpc.getGetServiceMethod) == null) {
          RegisterServiceGrpc.getGetServiceMethod = getGetServiceMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.QueryRequest, cn.edu.sdju.fengguoyu.proto.ServiceResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "getService"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.QueryRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServiceResponse.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("getService"))
              .build();
        }
      }
    }
    return getGetServiceMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.RegisterInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getRegisterServiceMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "registerService",
      requestType = cn.edu.sdju.fengguoyu.proto.RegisterInfo.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.RegisterInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getRegisterServiceMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.RegisterInfo, cn.edu.sdju.fengguoyu.proto.Response> getRegisterServiceMethod;
    if ((getRegisterServiceMethod = RegisterServiceGrpc.getRegisterServiceMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getRegisterServiceMethod = RegisterServiceGrpc.getRegisterServiceMethod) == null) {
          RegisterServiceGrpc.getRegisterServiceMethod = getRegisterServiceMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.RegisterInfo, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "registerService"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.RegisterInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("registerService"))
              .build();
        }
      }
    }
    return getRegisterServiceMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UpdateRankRequest,
      cn.edu.sdju.fengguoyu.proto.Response> getUpdateRankMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "updateRank",
      requestType = cn.edu.sdju.fengguoyu.proto.UpdateRankRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UpdateRankRequest,
      cn.edu.sdju.fengguoyu.proto.Response> getUpdateRankMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UpdateRankRequest, cn.edu.sdju.fengguoyu.proto.Response> getUpdateRankMethod;
    if ((getUpdateRankMethod = RegisterServiceGrpc.getUpdateRankMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getUpdateRankMethod = RegisterServiceGrpc.getUpdateRankMethod) == null) {
          RegisterServiceGrpc.getUpdateRankMethod = getUpdateRankMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UpdateRankRequest, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "updateRank"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UpdateRankRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("updateRank"))
              .build();
        }
      }
    }
    return getUpdateRankMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.RegisterInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getUnregisterServiceMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "unregisterService",
      requestType = cn.edu.sdju.fengguoyu.proto.RegisterInfo.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.RegisterInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getUnregisterServiceMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.RegisterInfo, cn.edu.sdju.fengguoyu.proto.Response> getUnregisterServiceMethod;
    if ((getUnregisterServiceMethod = RegisterServiceGrpc.getUnregisterServiceMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getUnregisterServiceMethod = RegisterServiceGrpc.getUnregisterServiceMethod) == null) {
          RegisterServiceGrpc.getUnregisterServiceMethod = getUnregisterServiceMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.RegisterInfo, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "unregisterService"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.RegisterInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("unregisterService"))
              .build();
        }
      }
    }
    return getUnregisterServiceMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getRegisterUserMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "registerUser",
      requestType = cn.edu.sdju.fengguoyu.proto.UserInfo.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getRegisterUserMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserInfo, cn.edu.sdju.fengguoyu.proto.Response> getRegisterUserMethod;
    if ((getRegisterUserMethod = RegisterServiceGrpc.getRegisterUserMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getRegisterUserMethod = RegisterServiceGrpc.getRegisterUserMethod) == null) {
          RegisterServiceGrpc.getRegisterUserMethod = getRegisterUserMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UserInfo, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "registerUser"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UserInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("registerUser"))
              .build();
        }
      }
    }
    return getRegisterUserMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getUnregisterUserMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "unregisterUser",
      requestType = cn.edu.sdju.fengguoyu.proto.UserInfo.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getUnregisterUserMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserInfo, cn.edu.sdju.fengguoyu.proto.Response> getUnregisterUserMethod;
    if ((getUnregisterUserMethod = RegisterServiceGrpc.getUnregisterUserMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getUnregisterUserMethod = RegisterServiceGrpc.getUnregisterUserMethod) == null) {
          RegisterServiceGrpc.getUnregisterUserMethod = getUnregisterUserMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UserInfo, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "unregisterUser"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UserInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("unregisterUser"))
              .build();
        }
      }
    }
    return getUnregisterUserMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.Ping,
      cn.edu.sdju.fengguoyu.proto.Timestamp> getHeartbeatMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "heartbeat",
      requestType = cn.edu.sdju.fengguoyu.proto.Ping.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Timestamp.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.Ping,
      cn.edu.sdju.fengguoyu.proto.Timestamp> getHeartbeatMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.Ping, cn.edu.sdju.fengguoyu.proto.Timestamp> getHeartbeatMethod;
    if ((getHeartbeatMethod = RegisterServiceGrpc.getHeartbeatMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getHeartbeatMethod = RegisterServiceGrpc.getHeartbeatMethod) == null) {
          RegisterServiceGrpc.getHeartbeatMethod = getHeartbeatMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.Ping, cn.edu.sdju.fengguoyu.proto.Timestamp>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "heartbeat"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Ping.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Timestamp.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("heartbeat"))
              .build();
        }
      }
    }
    return getHeartbeatMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserStatusRequest,
      cn.edu.sdju.fengguoyu.proto.UserStatusResponse> getGetUserStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "getUserStatus",
      requestType = cn.edu.sdju.fengguoyu.proto.UserStatusRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.UserStatusResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserStatusRequest,
      cn.edu.sdju.fengguoyu.proto.UserStatusResponse> getGetUserStatusMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UserStatusRequest, cn.edu.sdju.fengguoyu.proto.UserStatusResponse> getGetUserStatusMethod;
    if ((getGetUserStatusMethod = RegisterServiceGrpc.getGetUserStatusMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getGetUserStatusMethod = RegisterServiceGrpc.getGetUserStatusMethod) == null) {
          RegisterServiceGrpc.getGetUserStatusMethod = getGetUserStatusMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UserStatusRequest, cn.edu.sdju.fengguoyu.proto.UserStatusResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "getUserStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UserStatusRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UserStatusResponse.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("getUserStatus"))
              .build();
        }
      }
    }
    return getGetUserStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest,
      cn.edu.sdju.fengguoyu.proto.Response> getUpdateUserStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "updateUserStatus",
      requestType = cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest,
      cn.edu.sdju.fengguoyu.proto.Response> getUpdateUserStatusMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest, cn.edu.sdju.fengguoyu.proto.Response> getUpdateUserStatusMethod;
    if ((getUpdateUserStatusMethod = RegisterServiceGrpc.getUpdateUserStatusMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getUpdateUserStatusMethod = RegisterServiceGrpc.getUpdateUserStatusMethod) == null) {
          RegisterServiceGrpc.getUpdateUserStatusMethod = getUpdateUserStatusMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "updateUserStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("updateUserStatus"))
              .build();
        }
      }
    }
    return getUpdateUserStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getReportServiceStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "reportServiceStatus",
      requestType = cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getReportServiceStatusMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo, cn.edu.sdju.fengguoyu.proto.Response> getReportServiceStatusMethod;
    if ((getReportServiceStatusMethod = RegisterServiceGrpc.getReportServiceStatusMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getReportServiceStatusMethod = RegisterServiceGrpc.getReportServiceStatusMethod) == null) {
          RegisterServiceGrpc.getReportServiceStatusMethod = getReportServiceStatusMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "reportServiceStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("reportServiceStatus"))
              .build();
        }
      }
    }
    return getReportServiceStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ObserverInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getRegisterObserverMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "registerObserver",
      requestType = cn.edu.sdju.fengguoyu.proto.ObserverInfo.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ObserverInfo,
      cn.edu.sdju.fengguoyu.proto.Response> getRegisterObserverMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ObserverInfo, cn.edu.sdju.fengguoyu.proto.Response> getRegisterObserverMethod;
    if ((getRegisterObserverMethod = RegisterServiceGrpc.getRegisterObserverMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getRegisterObserverMethod = RegisterServiceGrpc.getRegisterObserverMethod) == null) {
          RegisterServiceGrpc.getRegisterObserverMethod = getRegisterObserverMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.ObserverInfo, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "registerObserver"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ObserverInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("registerObserver"))
              .build();
        }
      }
    }
    return getRegisterObserverMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest,
      cn.edu.sdju.fengguoyu.proto.Response> getUnregisterObserverMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "unregisterObserver",
      requestType = cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest,
      cn.edu.sdju.fengguoyu.proto.Response> getUnregisterObserverMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest, cn.edu.sdju.fengguoyu.proto.Response> getUnregisterObserverMethod;
    if ((getUnregisterObserverMethod = RegisterServiceGrpc.getUnregisterObserverMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getUnregisterObserverMethod = RegisterServiceGrpc.getUnregisterObserverMethod) == null) {
          RegisterServiceGrpc.getUnregisterObserverMethod = getUnregisterObserverMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "unregisterObserver"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("unregisterObserver"))
              .build();
        }
      }
    }
    return getUnregisterObserverMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ConnectedMessage,
      cn.edu.sdju.fengguoyu.proto.Response> getReportConnectedMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "reportConnected",
      requestType = cn.edu.sdju.fengguoyu.proto.ConnectedMessage.class,
      responseType = cn.edu.sdju.fengguoyu.proto.Response.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ConnectedMessage,
      cn.edu.sdju.fengguoyu.proto.Response> getReportConnectedMethod() {
    io.grpc.MethodDescriptor<cn.edu.sdju.fengguoyu.proto.ConnectedMessage, cn.edu.sdju.fengguoyu.proto.Response> getReportConnectedMethod;
    if ((getReportConnectedMethod = RegisterServiceGrpc.getReportConnectedMethod) == null) {
      synchronized (RegisterServiceGrpc.class) {
        if ((getReportConnectedMethod = RegisterServiceGrpc.getReportConnectedMethod) == null) {
          RegisterServiceGrpc.getReportConnectedMethod = getReportConnectedMethod =
              io.grpc.MethodDescriptor.<cn.edu.sdju.fengguoyu.proto.ConnectedMessage, cn.edu.sdju.fengguoyu.proto.Response>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "reportConnected"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.ConnectedMessage.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cn.edu.sdju.fengguoyu.proto.Response.getDefaultInstance()))
              .setSchemaDescriptor(new RegisterServiceMethodDescriptorSupplier("reportConnected"))
              .build();
        }
      }
    }
    return getReportConnectedMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static RegisterServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<RegisterServiceStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<RegisterServiceStub>() {
        @java.lang.Override
        public RegisterServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new RegisterServiceStub(channel, callOptions);
        }
      };
    return RegisterServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static RegisterServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<RegisterServiceBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<RegisterServiceBlockingStub>() {
        @java.lang.Override
        public RegisterServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new RegisterServiceBlockingStub(channel, callOptions);
        }
      };
    return RegisterServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static RegisterServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<RegisterServiceFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<RegisterServiceFutureStub>() {
        @java.lang.Override
        public RegisterServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new RegisterServiceFutureStub(channel, callOptions);
        }
      };
    return RegisterServiceFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class RegisterServiceImplBase implements io.grpc.BindableService {

    /**
     */
    public void queryServices(cn.edu.sdju.fengguoyu.proto.QueryRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServicesList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getQueryServicesMethod(), responseObserver);
    }

    /**
     */
    public void queryServiceDetail(cn.edu.sdju.fengguoyu.proto.QueryRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServicesDetailList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getQueryServiceDetailMethod(), responseObserver);
    }

    /**
     */
    public void getService(cn.edu.sdju.fengguoyu.proto.QueryRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServiceResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetServiceMethod(), responseObserver);
    }

    /**
     */
    public void registerService(cn.edu.sdju.fengguoyu.proto.RegisterInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRegisterServiceMethod(), responseObserver);
    }

    /**
     */
    public void updateRank(cn.edu.sdju.fengguoyu.proto.UpdateRankRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateRankMethod(), responseObserver);
    }

    /**
     */
    public void unregisterService(cn.edu.sdju.fengguoyu.proto.RegisterInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnregisterServiceMethod(), responseObserver);
    }

    /**
     */
    public void registerUser(cn.edu.sdju.fengguoyu.proto.UserInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRegisterUserMethod(), responseObserver);
    }

    /**
     */
    public void unregisterUser(cn.edu.sdju.fengguoyu.proto.UserInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnregisterUserMethod(), responseObserver);
    }

    /**
     */
    public void heartbeat(cn.edu.sdju.fengguoyu.proto.Ping request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Timestamp> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getHeartbeatMethod(), responseObserver);
    }

    /**
     */
    public void getUserStatus(cn.edu.sdju.fengguoyu.proto.UserStatusRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.UserStatusResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetUserStatusMethod(), responseObserver);
    }

    /**
     */
    public void updateUserStatus(cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateUserStatusMethod(), responseObserver);
    }

    /**
     */
    public void reportServiceStatus(cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getReportServiceStatusMethod(), responseObserver);
    }

    /**
     */
    public void registerObserver(cn.edu.sdju.fengguoyu.proto.ObserverInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRegisterObserverMethod(), responseObserver);
    }

    /**
     */
    public void unregisterObserver(cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnregisterObserverMethod(), responseObserver);
    }

    /**
     */
    public void reportConnected(cn.edu.sdju.fengguoyu.proto.ConnectedMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getReportConnectedMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getQueryServicesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.QueryRequest,
                cn.edu.sdju.fengguoyu.proto.ServicesList>(
                  this, METHODID_QUERY_SERVICES)))
          .addMethod(
            getQueryServiceDetailMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.QueryRequest,
                cn.edu.sdju.fengguoyu.proto.ServicesDetailList>(
                  this, METHODID_QUERY_SERVICE_DETAIL)))
          .addMethod(
            getGetServiceMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.QueryRequest,
                cn.edu.sdju.fengguoyu.proto.ServiceResponse>(
                  this, METHODID_GET_SERVICE)))
          .addMethod(
            getRegisterServiceMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.RegisterInfo,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_REGISTER_SERVICE)))
          .addMethod(
            getUpdateRankMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UpdateRankRequest,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_UPDATE_RANK)))
          .addMethod(
            getUnregisterServiceMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.RegisterInfo,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_UNREGISTER_SERVICE)))
          .addMethod(
            getRegisterUserMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UserInfo,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_REGISTER_USER)))
          .addMethod(
            getUnregisterUserMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UserInfo,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_UNREGISTER_USER)))
          .addMethod(
            getHeartbeatMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.Ping,
                cn.edu.sdju.fengguoyu.proto.Timestamp>(
                  this, METHODID_HEARTBEAT)))
          .addMethod(
            getGetUserStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UserStatusRequest,
                cn.edu.sdju.fengguoyu.proto.UserStatusResponse>(
                  this, METHODID_GET_USER_STATUS)))
          .addMethod(
            getUpdateUserStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_UPDATE_USER_STATUS)))
          .addMethod(
            getReportServiceStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_REPORT_SERVICE_STATUS)))
          .addMethod(
            getRegisterObserverMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.ObserverInfo,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_REGISTER_OBSERVER)))
          .addMethod(
            getUnregisterObserverMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_UNREGISTER_OBSERVER)))
          .addMethod(
            getReportConnectedMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cn.edu.sdju.fengguoyu.proto.ConnectedMessage,
                cn.edu.sdju.fengguoyu.proto.Response>(
                  this, METHODID_REPORT_CONNECTED)))
          .build();
    }
  }

  /**
   */
  public static final class RegisterServiceStub extends io.grpc.stub.AbstractAsyncStub<RegisterServiceStub> {
    private RegisterServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected RegisterServiceStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new RegisterServiceStub(channel, callOptions);
    }

    /**
     */
    public void queryServices(cn.edu.sdju.fengguoyu.proto.QueryRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServicesList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getQueryServicesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void queryServiceDetail(cn.edu.sdju.fengguoyu.proto.QueryRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServicesDetailList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getQueryServiceDetailMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getService(cn.edu.sdju.fengguoyu.proto.QueryRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServiceResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetServiceMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void registerService(cn.edu.sdju.fengguoyu.proto.RegisterInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRegisterServiceMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void updateRank(cn.edu.sdju.fengguoyu.proto.UpdateRankRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateRankMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void unregisterService(cn.edu.sdju.fengguoyu.proto.RegisterInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUnregisterServiceMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void registerUser(cn.edu.sdju.fengguoyu.proto.UserInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRegisterUserMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void unregisterUser(cn.edu.sdju.fengguoyu.proto.UserInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUnregisterUserMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void heartbeat(cn.edu.sdju.fengguoyu.proto.Ping request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Timestamp> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getHeartbeatMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getUserStatus(cn.edu.sdju.fengguoyu.proto.UserStatusRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.UserStatusResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetUserStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void updateUserStatus(cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateUserStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void reportServiceStatus(cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getReportServiceStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void registerObserver(cn.edu.sdju.fengguoyu.proto.ObserverInfo request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRegisterObserverMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void unregisterObserver(cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUnregisterObserverMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void reportConnected(cn.edu.sdju.fengguoyu.proto.ConnectedMessage request,
        io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getReportConnectedMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class RegisterServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<RegisterServiceBlockingStub> {
    private RegisterServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected RegisterServiceBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new RegisterServiceBlockingStub(channel, callOptions);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.ServicesList queryServices(cn.edu.sdju.fengguoyu.proto.QueryRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getQueryServicesMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.ServicesDetailList queryServiceDetail(cn.edu.sdju.fengguoyu.proto.QueryRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getQueryServiceDetailMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.ServiceResponse getService(cn.edu.sdju.fengguoyu.proto.QueryRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetServiceMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response registerService(cn.edu.sdju.fengguoyu.proto.RegisterInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRegisterServiceMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response updateRank(cn.edu.sdju.fengguoyu.proto.UpdateRankRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateRankMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response unregisterService(cn.edu.sdju.fengguoyu.proto.RegisterInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUnregisterServiceMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response registerUser(cn.edu.sdju.fengguoyu.proto.UserInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRegisterUserMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response unregisterUser(cn.edu.sdju.fengguoyu.proto.UserInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUnregisterUserMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Timestamp heartbeat(cn.edu.sdju.fengguoyu.proto.Ping request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getHeartbeatMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.UserStatusResponse getUserStatus(cn.edu.sdju.fengguoyu.proto.UserStatusRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetUserStatusMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response updateUserStatus(cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateUserStatusMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response reportServiceStatus(cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getReportServiceStatusMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response registerObserver(cn.edu.sdju.fengguoyu.proto.ObserverInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRegisterObserverMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response unregisterObserver(cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUnregisterObserverMethod(), getCallOptions(), request);
    }

    /**
     */
    public cn.edu.sdju.fengguoyu.proto.Response reportConnected(cn.edu.sdju.fengguoyu.proto.ConnectedMessage request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getReportConnectedMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class RegisterServiceFutureStub extends io.grpc.stub.AbstractFutureStub<RegisterServiceFutureStub> {
    private RegisterServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected RegisterServiceFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new RegisterServiceFutureStub(channel, callOptions);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.ServicesList> queryServices(
        cn.edu.sdju.fengguoyu.proto.QueryRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getQueryServicesMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.ServicesDetailList> queryServiceDetail(
        cn.edu.sdju.fengguoyu.proto.QueryRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getQueryServiceDetailMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.ServiceResponse> getService(
        cn.edu.sdju.fengguoyu.proto.QueryRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetServiceMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> registerService(
        cn.edu.sdju.fengguoyu.proto.RegisterInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRegisterServiceMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> updateRank(
        cn.edu.sdju.fengguoyu.proto.UpdateRankRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateRankMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> unregisterService(
        cn.edu.sdju.fengguoyu.proto.RegisterInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUnregisterServiceMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> registerUser(
        cn.edu.sdju.fengguoyu.proto.UserInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRegisterUserMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> unregisterUser(
        cn.edu.sdju.fengguoyu.proto.UserInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUnregisterUserMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Timestamp> heartbeat(
        cn.edu.sdju.fengguoyu.proto.Ping request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getHeartbeatMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.UserStatusResponse> getUserStatus(
        cn.edu.sdju.fengguoyu.proto.UserStatusRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetUserStatusMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> updateUserStatus(
        cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateUserStatusMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> reportServiceStatus(
        cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getReportServiceStatusMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> registerObserver(
        cn.edu.sdju.fengguoyu.proto.ObserverInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRegisterObserverMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> unregisterObserver(
        cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUnregisterObserverMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<cn.edu.sdju.fengguoyu.proto.Response> reportConnected(
        cn.edu.sdju.fengguoyu.proto.ConnectedMessage request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getReportConnectedMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_QUERY_SERVICES = 0;
  private static final int METHODID_QUERY_SERVICE_DETAIL = 1;
  private static final int METHODID_GET_SERVICE = 2;
  private static final int METHODID_REGISTER_SERVICE = 3;
  private static final int METHODID_UPDATE_RANK = 4;
  private static final int METHODID_UNREGISTER_SERVICE = 5;
  private static final int METHODID_REGISTER_USER = 6;
  private static final int METHODID_UNREGISTER_USER = 7;
  private static final int METHODID_HEARTBEAT = 8;
  private static final int METHODID_GET_USER_STATUS = 9;
  private static final int METHODID_UPDATE_USER_STATUS = 10;
  private static final int METHODID_REPORT_SERVICE_STATUS = 11;
  private static final int METHODID_REGISTER_OBSERVER = 12;
  private static final int METHODID_UNREGISTER_OBSERVER = 13;
  private static final int METHODID_REPORT_CONNECTED = 14;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final RegisterServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(RegisterServiceImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_QUERY_SERVICES:
          serviceImpl.queryServices((cn.edu.sdju.fengguoyu.proto.QueryRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServicesList>) responseObserver);
          break;
        case METHODID_QUERY_SERVICE_DETAIL:
          serviceImpl.queryServiceDetail((cn.edu.sdju.fengguoyu.proto.QueryRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServicesDetailList>) responseObserver);
          break;
        case METHODID_GET_SERVICE:
          serviceImpl.getService((cn.edu.sdju.fengguoyu.proto.QueryRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.ServiceResponse>) responseObserver);
          break;
        case METHODID_REGISTER_SERVICE:
          serviceImpl.registerService((cn.edu.sdju.fengguoyu.proto.RegisterInfo) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_UPDATE_RANK:
          serviceImpl.updateRank((cn.edu.sdju.fengguoyu.proto.UpdateRankRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_UNREGISTER_SERVICE:
          serviceImpl.unregisterService((cn.edu.sdju.fengguoyu.proto.RegisterInfo) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_REGISTER_USER:
          serviceImpl.registerUser((cn.edu.sdju.fengguoyu.proto.UserInfo) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_UNREGISTER_USER:
          serviceImpl.unregisterUser((cn.edu.sdju.fengguoyu.proto.UserInfo) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_HEARTBEAT:
          serviceImpl.heartbeat((cn.edu.sdju.fengguoyu.proto.Ping) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Timestamp>) responseObserver);
          break;
        case METHODID_GET_USER_STATUS:
          serviceImpl.getUserStatus((cn.edu.sdju.fengguoyu.proto.UserStatusRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.UserStatusResponse>) responseObserver);
          break;
        case METHODID_UPDATE_USER_STATUS:
          serviceImpl.updateUserStatus((cn.edu.sdju.fengguoyu.proto.UpdateUserStatusRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_REPORT_SERVICE_STATUS:
          serviceImpl.reportServiceStatus((cn.edu.sdju.fengguoyu.proto.ServiceStatusInfo) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_REGISTER_OBSERVER:
          serviceImpl.registerObserver((cn.edu.sdju.fengguoyu.proto.ObserverInfo) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_UNREGISTER_OBSERVER:
          serviceImpl.unregisterObserver((cn.edu.sdju.fengguoyu.proto.UnregisterObserverRequest) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        case METHODID_REPORT_CONNECTED:
          serviceImpl.reportConnected((cn.edu.sdju.fengguoyu.proto.ConnectedMessage) request,
              (io.grpc.stub.StreamObserver<cn.edu.sdju.fengguoyu.proto.Response>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class RegisterServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    RegisterServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return cn.edu.sdju.fengguoyu.proto.AhoEdgeRegisterService.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("RegisterService");
    }
  }

  private static final class RegisterServiceFileDescriptorSupplier
      extends RegisterServiceBaseDescriptorSupplier {
    RegisterServiceFileDescriptorSupplier() {}
  }

  private static final class RegisterServiceMethodDescriptorSupplier
      extends RegisterServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    RegisterServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (RegisterServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new RegisterServiceFileDescriptorSupplier())
              .addMethod(getQueryServicesMethod())
              .addMethod(getQueryServiceDetailMethod())
              .addMethod(getGetServiceMethod())
              .addMethod(getRegisterServiceMethod())
              .addMethod(getUpdateRankMethod())
              .addMethod(getUnregisterServiceMethod())
              .addMethod(getRegisterUserMethod())
              .addMethod(getUnregisterUserMethod())
              .addMethod(getHeartbeatMethod())
              .addMethod(getGetUserStatusMethod())
              .addMethod(getUpdateUserStatusMethod())
              .addMethod(getReportServiceStatusMethod())
              .addMethod(getRegisterObserverMethod())
              .addMethod(getUnregisterObserverMethod())
              .addMethod(getReportConnectedMethod())
              .build();
        }
      }
    }
    return result;
  }
}
